/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: happyiu
 * Date: 2021-11-13
 * Time: 18:14
 */
/*
class func{
    public int a;
    public static int count;

    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员
    }
}

public class TestDemo{
    public static void main(String[] args) {
    func.change();//无需创建实例对象 就可以调用
    System.out.println(func.count);
   }
}
*/

/*class Person {
    public int age;//实例变量   存放在对象内
    public String name;//实例变量
    public String sex;//实例变量
    public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
    public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
    public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改
    //实例成员函数
    public void eat() {
        int a = 10;//局部变量
        System.out.println("eat()!");
    }
    //实例成员函数
    public void sleep() {
        System.out.println("sleep()!");
    }
    //静态成员函数
    public static void staticTest(){
        //不能访问非静态成员
        //sex = "man"; error
        System.out.println("StaticTest()");
    }
}
public class TestDemo {
    public static void main(String[] args) {

        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!
        //正确访问方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
    }
}*/
//
//        0
//        null
//        0
//        99
//        StaticTest()
//        eat()!
//        sleep()!

/*class Person {
    private String name = "张三";
    private int age = 18;

    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
}

class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 20;
        person.show();
    }
}
// 编译出错
//Test.java:13: 错误: age可以在Person中访问private
//        person.age = 20;
//        ^
//        1 个错误*/

/*class Person {
    private String name;//实例成员变量
    private int age;

    public void setName(String name){
        //name = name;//不能这样写
        this.name = name;//this引用，表示调用该方法的对象
    }
    public String getName(){
        return name;
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age);
    }
}
    public class TestDemo{
        public static void main(String[] args) {
            Person person = new Person();
            person.setName("caocao");
            String name = person.getName();
            System.out.println(name);
            person.show();
        }
    }
// 运行结果
//caocao
//        name: caocao age: 0*/

/*
class Person {

    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
        this.name = "caocao";
        this.age = 10;
        this.sex = "男";
    }
    //带有3个参数的构造函数
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }

}

public class TestDemo{
    public static void main(String[] args) {
        Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
        p2.show();
    }
}
// 执行结果
//name: caocao age: 10 sex: 男
//name: zhangfei age: 80 sex: 男
*/

class Person {

    private String name;//实例成员变量
    private int age;

    public Person(String name) {
        System.out.println(name+"调用了构造方法！");
    }

}

public class TestDemo{
    public static void main(String[] args) {
        Person p1 = new Person("hahaha");
        //调用不带参数的构造函数
    }
}